﻿#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <assert.h>

using namespace std;
template<class T>
class Vector {
public :
	// Vector迭代器
	typedef T* iterator;
	// const版本
	typedef const T* const_iterator;
	// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	// 无参构造函数
	Vector() 
		:_start(nullptr)
		,_finish(nullptr)
		,_end(nullptr)
	{
	}
	// 以n个相同值构造
	Vector(size_t n, const T& val = T()) {
		// 申请空间
		T* temp = new T[n];
		// 插入数据
		for (size_t i = 0; i < n; i++) {
			temp[i] = val;
		}
		_start = temp;
		_finish = temp + n;
		_end = _finish;
	}
	// 以一段迭代器区间初始化
	template <class InputIterator>
	Vector(InputIterator first, InputIterator last) {
		// 开空间
		T* temp = new T[last - first];
		// 插入数据
		int i = 0;
		while (first < last) {
			temp[i] = *first;
			first++;
			i++;
		}
		_start = temp;
		_finish = _end = temp + i;
	}
	
	
	// 拷贝构造
	Vector(const Vector<T>& v) {
		// 申请新空间
		T* temp = new T[v.capacity()];
		// 拷贝数据
		int i = 0;
		for (auto it : v) {
			temp[i] = it;
			i++;
		}
		_start = temp;
		_finish = _start + v.size();
		_end = _start + v.capacity();
	}
	// 赋值运算符重载
	Vector<T>& operator=(const Vector<T>& v) {
		// 申请新空间
		T* temp = new T[v.capacity()];
		// 拷贝数据
		int i = 0;
		for (auto it : v) {
			temp[i] = it;
			i++;
		}
		if (_start) {
			// 释放原来的空间
			delete[] _start;
		}
		_start = temp;
		_finish = _start + v.size();
		_end = _start + v.capacity();
		return *this;
	}
	// 析构函数
	~Vector() {
		delete[] _start;
		_start = _finish = _end = nullptr;
	}

	// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 返回长度
	size_t size() const {
		return _finish - _start;
	}
	// 返回容量
	size_t capacity() const {
		return _end - _start;
	}
	// 扩容
	void reverse(size_t newCapacity) {
		if (newCapacity > capacity()) {
			// 保存原来的偏移量
			size_t offset = size();
			// 申请新空间
			T* temp = new T[newCapacity];
			// 拷贝数据
			int i = 0;
			for (auto it : *this) {
				temp[i] = it;
				i++;
			}
			// 释放原来的空间
			delete[] _start;
			_start = temp;
			_finish = _start + offset;
			_end = _start + newCapacity;
		}
	}
	// 重置长度
	void resize(size_t newLen, const T& val = T()) {
		if (newLen > size()) {
			if (newLen > capacity()) {
				// 扩容
				reverse(newLen);
			}
			// 填充数据
			while (_finish < (_start + newLen)) {
				*_finish = val;
				_finish++;
			}
		}
		_finish = _start + newLen;
	}

	// 判断是否为空
	bool empty() {
		return _start == _finish;
	}

	// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 迭代器起始位置
	iterator begin() {
		return _start;
	}
	// 迭代器结束位置
	iterator end() {
		return _finish;
	}

	// cosnt版本迭代器起始位置
	const_iterator begin() const {
		return _start;
	}
	// const版本迭代器结束位置
	const_iterator end() const {
		return _finish;
	}
	// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	T& operator[](size_t pos) {
		assert(pos < size());
		return _start[pos];
	}

	const T& operator[](size_t pos) const {
		assert(pos < size());
		return _start[pos];
	}
	// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 尾插
	void push_back(const T& val) {
		// 检查扩容
		if (size() == capacity()) {
			reverse(capacity() == 0 ? 4 : 2 * capacity());
		}
		*_finish = val;
		_finish++;
	}
	// 尾删
	void pop_back() {
		assert(!empty());
		_finish--;
	}

	// 交换
	void Swap(Vector<T>& v) {
		swap(_start, v._start);
		swap(_finish, v._finish);
		swap(_end, v._end);
	}
	// 在pos位置插入一个值，并返回新插入的这个值的位置
	iterator insert(iterator pos, const T& val) {
		assert(pos <= end());
		size_t offset = pos - _start;
		// 检查扩容
		if (size() == capacity()) {
			reverse(capacity() == 0 ? 4 : 2 * capacity());
		}
		// 更新pos
		pos = _start + offset;
		iterator end = _finish - 1;
		// 挪动数据
		while (end >= pos) {
			*(end + 1) = *end;
			end--;
		}
		*pos = val;
		_finish++;
		return pos;
	}
	// 删除pos位置上的一个值，并返回删除位置下一个元素的在删除后的位置
	iterator erase(iterator pos) {
		assert(!empty());
		assert(pos < end());
		iterator begin = pos;
		// 挪动数据
		while (begin < end() - 1) {
			*begin = *(begin + 1);
			begin++;
		}
		_finish--;
		return pos + 1;
	}

private :
	iterator _start; // 指向数据块起始位置
	iterator _finish; // 指向有效数据结束位置
	iterator _end; // 指向存储容量结尾位置
};


int main() {
	Vector<string> v1(10, "OMG");
	for (auto it : v1) {
		cout << it << " ";
	}
	cout << endl;
	v1.insert(v1.begin() + 3, "hello world!!");
	for (auto it : v1) {
		cout << it << " ";
	}
	cout << endl;
	v1.erase(v1.begin() + 3);
	for (auto it : v1) {
		cout << it << " ";
	}
	cout << endl;

	return 0;
}

